# -*- coding: utf-8 -*-
from datetime import timedelta
from django.core.context_processors import request
from django.http import Http404
from django.http.response import HttpResponse
from django.shortcuts import render_to_response, redirect
from django.template import RequestContext
from django.utils import simplejson
from django.views.decorators.csrf import csrf_exempt
from indicadores.models import IndicadoresBooleanos, IndicadoresEnteros, IndicadoresPorcentaje, IndicadoresChoices, RespuestaBooleanos, RespuestaEnteros, RespuestaPorcentaje, RespuestaChoices, \
    RespuestaTexto
from universidades.models import Universidad
from universidades.views import sidebar
from validaciones.models import checkpermiso, respuestahttp, getAdminIns
import cgi
import datetime
import re
from locale import str


Permisos = ['validaciones.Participantes_Publico']

def agregarModal(tipo_indicador, id_indicador):

    if tipo_indicador == '1':
        indicador = IndicadoresBooleanos.objects.get(id=id_indicador)
    elif tipo_indicador == '2':
        indicador = IndicadoresEnteros.objects.get(id=id_indicador)
    elif tipo_indicador == '3':
        indicador = IndicadoresChoices.objects.get(id=id_indicador)
    elif tipo_indicador == '4':
        indicador = IndicadoresPorcentaje.objects.get(id=id_indicador)

    id_modal = u"myModal-" + unicode(tipo_indicador) + u"-" + unicode(id_indicador)
    boton_eliminacion = u'<a class="btn btn-primary" href="/plataforma/indicadores/administrar/' + unicode(tipo_indicador) + u'/' + unicode(id_indicador) + u'">Confirmar y eliminar indicador</a>'
    mensaje_modal = u"<b>Seguro que desea eliminar: </b><i>" + unicode(indicador.nombre) + u"</i>"

    formModal = u"""<tr><td colspan="3">
    <div id='""" + unicode(id_modal) + u"""' class="modal hide fade" tabindex="-1" role="dialog" aria-labelledby="myModalLabel" aria-hidden="true">
                        <div class="modal-header">
                            <h3>Confirmar eliminación de indicador
                            <button type="button" class="close" data-dismiss="modal" aria-hidden="true">
                                ×
                            </button>
                            </h3>

                            <h3 id="myModalLabel"></h3>
                        </div>
                        <div id="mensaje-modal" class="modal-body">
                            """ + unicode(mensaje_modal) + u"""
                        </div>
                        <div class="modal-footer">
                            <button class="btn" data-dismiss="modal" aria-hidden="true">
                                Cancelar
                            </button>
                            """ + unicode(boton_eliminacion) + u"""
                        </div>
                    </div><td><tr>
    """
    return formModal

def administrar(request, tabla= -1, id= -1):
    if checkpermiso(request.user, Permisos):
        return HttpResponse(respuestahttp())
    if request.user.is_staff:  # solo si tiene permiso de Staff
        mensaje_eliminacion = ""
    
        if int(tabla) != -1 and int(id) != -1 :
            if tabla == '1':
                indicador = IndicadoresBooleanos.objects.get(id=id)
                mensaje_eliminacion = "Ha eliminado correctamente el indicador: <i>" + unicode(indicador.nombre) + "</i>"
                IndicadoresBooleanos.objects.filter(id=id).delete()
            if tabla == '2':
                indicador = IndicadoresEnteros.objects.get(id=id)
                mensaje_eliminacion = "Ha eliminado correctamente el indicador: <i>" + unicode(indicador.nombre) + "</i>"
                IndicadoresEnteros.objects.filter(id=id).delete()
            if tabla == '3':
                indicador = IndicadoresChoices.objects.get(id=id)
                mensaje_eliminacion = "Ha eliminado correctamente el indicador: <i>" + unicode(indicador.nombre) + "</i>"
                IndicadoresChoices.objects.filter(id=id).delete()
            if tabla == '4':
                indicador = IndicadoresPorcentaje.objects.get(id=id)
                mensaje_eliminacion = "Ha eliminado correctamente el indicador: <i>" + unicode(indicador.nombre) + "</i>"
                IndicadoresPorcentaje.objects.filter(id=id).delete()
    
        if request.method == 'POST':
            dimension = request.POST['dimension']
            indicador = request.POST['nombre']
            tabla = request.POST['tabla']
            id = request.POST['id']
            if int(id) != 99999:
                if tabla == '1':
                    respuesta = IndicadoresBooleanos(id=id, dimension=dimension, nombre=indicador)
                    respuesta.save()
    
                if tabla == '2':
                    respuesta = IndicadoresEnteros(id=id, dimension=dimension, nombre=indicador)
                    respuesta.save()
    
                if tabla == '3':
                    respuesta = IndicadoresChoices(id=id, dimension=dimension, nombre=indicador)
                    respuesta.save()
    
                if tabla == '4':
                    respuesta = IndicadoresPorcentaje(id=id, dimension=dimension, nombre=indicador)
                    respuesta.save()
            else:
                if tabla == '1':
                    respuesta = IndicadoresBooleanos(dimension=dimension, nombre=indicador)
                    respuesta.save()
    
                if tabla == '2':
                    respuesta = IndicadoresEnteros(dimension=dimension, nombre=indicador)
                    respuesta.save()
    
                if tabla == '3':
                    respuesta = IndicadoresChoices(dimension=dimension, nombre=indicador)
                    respuesta.save()
    
                if tabla == '4':
                    respuesta = IndicadoresPorcentaje(dimension=dimension, nombre=indicador)
                    respuesta.save()
    
    
    
        url = request.get_full_path()
        var_indicadores = '<form novalidate action="." method="post" class="form-horizontal" enctype="multipart/form-data" data-validate="parsley"> '
        indicadores_booleanos = IndicadoresBooleanos.objects.all().order_by('nombre')
        indicadores_enteros = IndicadoresEnteros.objects.all().order_by('nombre')
        indicadores_choices = IndicadoresChoices.objects.all().order_by('nombre')
        indicadores_porcentaje = IndicadoresPorcentaje.objects.all().order_by('nombre')
        mtx = {
            'url': url,
            'var_indicadores' : var_indicadores,
            'indicadores_booleanos': indicadores_booleanos,
            'indicadores_enteros': indicadores_enteros,
            'indicadores_porcentaje': indicadores_porcentaje,
            'indicadores_choices': indicadores_choices
            }
        mtx = desplegar_indicadores(mtx)
    
        menu = sidebar(request)
        mtx.update({
            'menu' : menu,
            'mensaje_eliminacion' : mensaje_eliminacion,
        })
        return render_to_response('administracion.html', mtx, context_instance=RequestContext(request))
    else:
        html = "<html><body><h1>Acceso denegado</h1><a href=\"/plataforma\"> Volver a la pagina de inicio</a></body></html>"
        return HttpResponse( html )

def edicion(request, id, tabla, dimension):
    mtx = {}
    if tabla == '1':
        indicadores_booleanos = IndicadoresBooleanos.objects.filter(id=id)
        mtx.update({'indicador': indicadores_booleanos[0]})
    if tabla == '2':
        indicadores_enteros = IndicadoresEnteros.objects.filter(id=id)
        mtx.update({'indicador': indicadores_enteros[0]})
    if tabla == '3':
        indicadores_choices = IndicadoresChoices.objects.filter(id=id)
        mtx.update({'indicador': indicadores_choices[0]})
    if tabla == '4':
        indicadores_porcentaje = IndicadoresPorcentaje.objects.filter(id=id)
        mtx.update({'indicador': indicadores_porcentaje[0]})

    menu = sidebar(request)
    mtx.update({'dimension': dimension})
    mtx.update({'tabla':tabla})
    mtx.update({'id':id})
    mtx.update({'menu':menu})
    return render_to_response('edicion.html', mtx, context_instance=RequestContext(request))

def agregar(request):
    menu = sidebar(request)
    mtx = {'menu':menu}
    return render_to_response('agregar.html', mtx, context_instance=RequestContext(request))

def eliminar_informe(request , codigo_informe):
    universidad_pedida = Universidad.objects.get(administrador=request.user)

    informe_auxiliar = RespuestaTexto.objects.get(id=codigo_informe)

    try:
        RespuestaBooleanos.objects.filter(fecha_inicio=informe_auxiliar.fecha_inicio, fecha_fin=informe_auxiliar.fecha_fin).delete()
        RespuestaChoices.objects.filter(fecha_inicio=informe_auxiliar.fecha_inicio, fecha_fin=informe_auxiliar.fecha_fin).delete()
        RespuestaEnteros.objects.filter(fecha_inicio=informe_auxiliar.fecha_inicio, fecha_fin=informe_auxiliar.fecha_fin).delete()
        RespuestaPorcentaje.objects.filter(fecha_inicio=informe_auxiliar.fecha_inicio, fecha_fin=informe_auxiliar.fecha_fin).delete()
        RespuestaTexto.objects.filter(id=codigo_informe).delete()
    except e:
        raise e

    url = "/plataforma/indicadores/listar_informes_anteriores/" + str(universidad_pedida.id) + "?message='Se ha eliminado correctamente el informe.'"
    return redirect(url)

def desplegar_indicadores(mtx):
    indicadores = []
    lista_indicadores = '<br><br><table border = "0" class="table"><tr>'

    lista_indicadores = lista_indicadores + u'<td colspan = "3"><h4><b>Formación Continua</b></h4></td></tr>'
    for item in mtx['indicadores_booleanos']:

        if item.dimension == 1:
            indicadores.append((item.nombre, 1, item.id, 1))
    for item in mtx['indicadores_enteros']:
        if item.dimension == 1:
            indicadores.append((item.nombre, 2, item.id, 1))
    for item in mtx['indicadores_choices']:
        if item.dimension == 1:
            indicadores.append((item.nombre, 3, item.id, 1))
    for item in mtx['indicadores_porcentaje']:
        if item.dimension == 1:
            indicadores.append((item.nombre, 4, item.id, 1))

    indicadores.sort()
    for val in indicadores:
        lista_indicadores += agregarModal(unicode(val[1]), unicode(val[2]))
        lista_indicadores += '<tr ><td width = "75%" ><b>' + val[0] + '</b></td>'
        lista_indicadores += '<td width = "10%" align = "center"><a class="btn btn-primary" href="/plataforma/indicadores/edicion/' + unicode(val[1]) + '/' + unicode(val[2]) + '/' + unicode(val[3]) + '">Editar</a></td>'
        id_modal = "myModal-" + unicode(val[1]) + "-" + unicode(val[2])
        boton_lanza_modal = '<button type="button" class="btn btn-primary" data-toggle="modal" data-target="#' + unicode(id_modal) + '">Eliminar</button>'
        lista_indicadores += '<td width = "10%" align = "center">' + boton_lanza_modal + '</td></tr>'


    indicadores = []
    lista_indicadores = lista_indicadores + u'<tr><td colspan = "3"><h4><b>Transferencia del conocimiento e innovación</b></h4></td></tr>'
    for item in mtx['indicadores_booleanos']:
        if item.dimension == 2:
            indicadores.append((item.nombre, 1, item.id, 2))

    for item in mtx['indicadores_enteros']:
        if item.dimension == 2:
            indicadores.append((item.nombre, 2, item.id, 2))

    for item in mtx['indicadores_choices']:
        if item.dimension == 2:
            indicadores.append((item.nombre, 3, item.id, 2))

    for item in mtx['indicadores_porcentaje']:
        if item.dimension == 2:
            indicadores.append((item.nombre, 4, item.id, 2))

    indicadores.sort()
    for val in indicadores:
        lista_indicadores += agregarModal(unicode(val[1]), unicode(val[2]))
        lista_indicadores += '<tr ><td width = "75%" ><b>' + val[0] + '</b></td>'
        lista_indicadores += '<td width = "10%" align = "center"><a class="btn btn-primary" href="/plataforma/indicadores/edicion/' + unicode(val[1]) + '/' + unicode(val[2]) + '/' + unicode(val[3]) + '">Editar</a></td>'
        id_modal = "myModal-" + unicode(val[1]) + "-" + unicode(val[2])
        boton_lanza_modal = '<button type="button" class="btn btn-primary" data-toggle="modal" data-target="#' + unicode(id_modal) + '">Eliminar</button>'
        lista_indicadores += '<td width = "10%" align = "center">' + boton_lanza_modal + '</td></tr>'


    indicadores = []
    lista_indicadores = lista_indicadores + '</tr><tr><td colspan = "3"><h4><b>Compromiso Social</b></h4></td></tr>'
    for item in mtx['indicadores_booleanos']:
        if item.dimension == 3:
            indicadores.append((item.nombre, 1, item.id, 3))

    for item in mtx['indicadores_enteros']:
        if item.dimension == 3:
            indicadores.append((item.nombre, 2, item.id, 3))

    for item in mtx['indicadores_choices']:
        if item.dimension == 3:
            indicadores.append((item.nombre, 3, item.id, 3))

    for item in mtx['indicadores_porcentaje']:
        if item.dimension == 3:
            indicadores.append((item.nombre, 4, item.id, 3))

    indicadores.sort()
    for val in indicadores:
        lista_indicadores += agregarModal(unicode(val[1]), unicode(val[2]))
        lista_indicadores += '<tr ><td width = "75%" ><b>' + val[0] + '</b></td>'
        lista_indicadores += '<td width = "10%" align = "center"><a class="btn btn-primary" href="/plataforma/indicadores/edicion/' + unicode(val[1]) + '/' + unicode(val[2]) + '/' + unicode(val[3]) + '">Editar</a></td>'
        id_modal = "myModal-" + unicode(val[1]) + "-" + unicode(val[2])
        boton_lanza_modal = '<button type="button" class="btn btn-primary" data-toggle="modal" data-target="#' + unicode(id_modal) + '">Eliminar</button>'
        lista_indicadores += '<td width = "10%" align = "center">' + boton_lanza_modal + '</td></tr>'

    lista_indicadores = lista_indicadores + '</table>'
    mtx.update({'lista_indicadores':lista_indicadores})
    return mtx

def formulario(request, formulario_nuevo , formulario_edicion_nro):


    url = request.get_full_path()
    # Verificacion de permisos.
    is_adm_institucional = getAdminIns(request)
    # si no es adm. institucional no puede acceder al formulario
    if not is_adm_institucional:
        return redirect('/plataforma')

    # Esta variable indica si el formulario es nuevo o esta siendo editado o guardado.
    info_enviado = 'Iniciado'

    if not request.method == 'POST':
        # Indica que debe crearse un nuevo formulario, inicializado con valores default.
        dtx = inicializacionFormIndicadores(request, info_enviado, formulario_nuevo , formulario_edicion_nro)
    else:
        # Debe proceder a validar los datos para luego almacenarlos en el sistema.
        bandera_validacion , mensaje_error = validar_datos_cargados(request)

        if bandera_validacion:

            # Texto de Resumen
            fecha_inicio_tmp , mensaje_error = obtenerFecha(request, 'inicio')
            fecha_fin_tmp , mensaje_error = obtenerFecha(request, 'fin')

            fecha_inicio_parametro, fecha_fin_parametro = guardarRespuestaTexto(request, fecha_inicio_tmp, fecha_fin_tmp)


            # Respuestas Booleanas
            indicadores_booleanos = IndicadoresBooleanos.objects.all().order_by('nombre')
            universidad = Universidad.objects.get(administrador=request.user.id)
            for item in indicadores_booleanos:
                respuesta_html = 'booleano_' + unicode(item.id)
                if request.POST.has_key(respuesta_html):
                    if not request.POST[respuesta_html] == '':
                        guardarRespuestaIndicador(IndicadoresBooleanos, RespuestaBooleanos, fecha_inicio_tmp, fecha_fin_tmp, fecha_inicio_parametro, fecha_fin_parametro , item.id, universidad, int(request.POST[respuesta_html]))



            # Respuestas Choices
            indicadores_choices = IndicadoresChoices.objects.all().order_by('nombre')
            for item in indicadores_choices:
                respuesta_html = 'choice_' + unicode(item.id)
                if request.POST.has_key(respuesta_html):
                    if not request.POST[respuesta_html] == '':
                        guardarRespuestaIndicador(IndicadoresChoices, RespuestaChoices, fecha_inicio_tmp, fecha_fin_tmp, fecha_inicio_parametro, fecha_fin_parametro , item.id, universidad, int(request.POST[respuesta_html]))


            # Respuestas Enteras
            indicadores_enteros = IndicadoresEnteros.objects.all().order_by('nombre')
            for item in indicadores_enteros:
                respuesta_html = 'entero_' + unicode(item.id)
                if request.POST.has_key(respuesta_html):
                    if not request.POST[respuesta_html] == '':
                        guardarRespuestaIndicador(IndicadoresEnteros, RespuestaEnteros, fecha_inicio_tmp, fecha_fin_tmp, fecha_inicio_parametro, fecha_fin_parametro , item.id, universidad, float("%.2f" % float(request.POST[respuesta_html])))

            # Respuestas Porcentaje
            indicadores_porcentaje = IndicadoresPorcentaje.objects.all().order_by('nombre')
            for item in indicadores_porcentaje:
                respuesta_html = 'porcentaje_' + unicode(item.id)
                if request.POST.has_key(respuesta_html):
                    if not request.POST[respuesta_html] == '':
                        guardarRespuestaIndicador(IndicadoresPorcentaje, RespuestaPorcentaje, fecha_inicio_tmp, fecha_fin_tmp, fecha_inicio_parametro, fecha_fin_parametro , item.id, universidad, float("%.1f" % float(request.POST[respuesta_html])))

            info_enviado = 'Guardado'
            return redirect('/plataforma/home/' + "?message=El formulario fue guardado con exito.")
        else:
            info_enviado = 'Error'

    menu = sidebar(request)

    return render_to_response('formulario_indicadores.html' , locals(), context_instance=RequestContext(request))

def guardarRespuestaIndicador(Indicador, Respuesta, fecha_inicio_pedido, fecha_fin_pedido, fecha_inicio_parametro, fecha_fin_parametro, id_indicador, universidad_parametro, respuesta_parametro):

    # CASO NUEVO
    cantidad_respuestas = 0
    if not fecha_inicio_parametro == '' and not fecha_fin_parametro == '':
        respuesta_vieja = Respuesta.objects.filter(indicador=Indicador.objects.get(id=id_indicador), fecha_inicio=fecha_inicio_parametro, fecha_fin=fecha_fin_parametro)
        cantidad_respuestas = respuesta_vieja.count()

    if cantidad_respuestas == 0:
        # CREAR NUEVA INSTANCIA
        respuesta_instancia = Respuesta(
                                    indicador=Indicador.objects.get(id=id_indicador),
                                    respuesta=respuesta_parametro,
                                    universidad=universidad_parametro,
                                    fecha_inicio=fecha_inicio_pedido,
                                    fecha_fin=fecha_fin_pedido
                                    )
        respuesta_instancia.save()
        return 1
    elif cantidad_respuestas > 0:
        # EDITAR EL CAMPO
        respuesta_instancia = Respuesta.objects.get(id=respuesta_vieja[0].id)
        respuesta_instancia.respuesta = respuesta_parametro
        respuesta_instancia.fecha_inicio = fecha_inicio_pedido
        respuesta_instancia.fecha_fin = fecha_fin_pedido
        respuesta_instancia.save()
        return 1
    else:
        return 0


def guardarRespuestaTexto(request, fecha_inicio, fecha_fin):
    # VERIFICAR SI ES FORMULARIO NUEVO O SI HAY QUE EDITARLO.
    # CASO FORMULARIO EDITADO, ALTERAR LOS VALORES.
    try:
        respuesta_texto = RespuestaTexto.objects.get(id=request.POST['id_formulario'])
        respuesta_texto.respuesta = request.POST['resumen']
        if 'archivo' in request.FILES:
            respuesta_texto.archivo = request.FILES['archivo']

        fecha_inicio_parametro = respuesta_texto.fecha_inicio
        fecha_fin_parametro = respuesta_texto.fecha_fin
        respuesta_texto.fecha_inicio = fecha_inicio
        respuesta_texto.fecha_fin = fecha_fin
        respuesta_texto.save()
        return fecha_inicio_parametro, fecha_fin_parametro

    except RespuestaTexto.DoesNotExist:
        # CASO FORMULARIO NUEVO, CREAR UNA NUEVA INSTANCIA Y ALMACENARLO.
        if 'archivo' in request.FILES:
            respuesta_texto = RespuestaTexto()
            respuesta_texto.respuesta = request.POST['resumen']
            respuesta_texto.universidad = Universidad.objects.get(administrador=request.user.id)
            respuesta_texto.archivo = request.FILES['archivo']
            respuesta_texto.fecha_inicio = fecha_inicio
            respuesta_texto.fecha_fin = fecha_fin
        else:
            respuesta_texto = RespuestaTexto()
            respuesta_texto.respuesta = request.POST['respuesta']
            respuesta_texto.universidad = Universidad.objects.get(administrador=request.user.id)
            respuesta_texto.fecha_inicio = fecha_inicio
            respuesta_texto.fecha_fin = fecha_fin
        respuesta_texto.save()
        return '', ''


def inicializacionFormIndicadores(request, info_enviado , formulario_nuevo=0 , formulario_viejo_pedido=0):
    url = request.get_full_path()
    is_adm_institucional = request.user.groups.filter(name='Adm. Institucional').exists()

    # INICIADO IMPLICA QUE UN FORMULARIO DESEA SER CREADO O EDITADO
    if info_enviado == 'Iniciado':
        # DEFINIMOS LAS DIMENSIONES DE VINCULA ENTORNOS
        dimensiones = [(1, u'Formación Continua'), (2, u'Transferencia del conocimiento e innovación'), (3, u'Compromiso social')]

        try:
            # Guarda el objecto universidad cuyo formulario debe ser editado.
            universidad_pedida = Universidad.objects.get(administrador=request.user)

            try:
                # Buscar informe anterior actual de esa universidad.
                print type(formulario_viejo_pedido)
                if formulario_viejo_pedido == unicode('0'):
                    informe_previo = RespuestaTexto.objects.filter(universidad=universidad_pedida).order_by('-fecha_fin')
                else:
                    informe_previo = RespuestaTexto.objects.filter(universidad=universidad_pedida, id=formulario_viejo_pedido)

                if informe_previo:
                    # Recibe el ultima
                    formulario_nro = informe_previo[0].id
                else:
                    formulario_nro = 0

            except RespuestaTexto.DoesNotExist:
                formulario_nro = 0

        except Exception , e:
            raise e

        # COMTEMPLAR CASOS COMO:
        # SIN INICIALIZACION PREVIA
            # FORMULARIO NUEVO SIN NINGUN INFORME CARGADO ANTERIORMENTE (Hecho)
        # CON INICIALIZACION PREVIA
            # FORMULARIO NUEVO PERO CON DATOS DEL ULTIMO INFORME CARGADO ANTERIORMENTE
            # EDICION DE UN INFORME
        if formulario_nuevo == '1' and formulario_nro == 0:
            # Formulario nuevo, sin informes previos
            fecha_inicio_previo = ''
            fecha_fin_previo = ''
            resumen_previo = ''
            archivo_previo = ''
        elif formulario_nuevo == '0' and not formulario_nro == 0:
            # Caso formulario en edicion
            fecha_inicio_previo = informe_previo[0].fecha_inicio
            fecha_fin_previo = informe_previo[0].fecha_fin
            resumen_previo = informe_previo[0].respuesta
            archivo_previo = informe_previo[0].archivo
        elif formulario_nuevo == '1' and not formulario_nro == 0:
            # Caso formulario nuevo pero con algun informe anterior
            fecha_inicio_previo = informe_previo[0].fecha_inicio
            fecha_fin_previo = informe_previo[0].fecha_fin
            resumen_previo = ''
            archivo_previo = ''

        cabecera_formulario = '<form id="form-indicadores" novalidate action="." method="post" class="form-horizontal" enctype="multipart/form-data">'
        form_indicadores = '<fielset>'

        if fecha_inicio_previo == '' and fecha_fin_previo == '':
            form_indicadores += inicializa_periodo_form(fecha_inicio_previo, fecha_fin_previo)
        elif formulario_nuevo == '0' and not formulario_nro == 0:
            # EDICION DE FORMULARIO
            form_indicadores += inicializa_periodo_form(fecha_inicio_previo.strftime("%d/%m/%Y"), fecha_fin_previo.strftime("%d/%m/%Y"))
        elif formulario_nuevo == '1' and not formulario_nro == 0:
            # NUEVO FORMULARIO PERO CON VALORES DEL ULTIMO INFORME
            form_indicadores += """
            <div id="alerta-precarga" class="alert alert-info"> Para su comodidad, el formulario a sido pre-cargado con datos de un informe anterior cuyo periodo corresponde a
            """ + fecha_inicio_previo.strftime("%d/%m/%Y") + """ al """ + fecha_fin_previo.strftime("%d/%m/%Y") + """. En caso de que de que desee limpiar el formulario, siga el siguente
            link <br><br><input class="btn btn-inverse" onclick="clear_form_elements(this.form)" type="button" value="Limpiar formulario" /></div>
            """
            form_indicadores += inicializa_periodo_form((fecha_fin_previo + timedelta(days=1)).strftime("%d/%m/%Y") , '')

        form_indicadores += inicializa_resumen_form(resumen_previo)
        form_indicadores += inicializa_archivo_form(archivo_previo)
        form_indicadores += '</fielset>'

        lista_indicadores = obtener_lista_indicadores()

        # INICIALIZAR ACORDE SI SE ESTA EDITANDO O EN CASO QUE SEA NUEVO, CON LOS DATOS DEL ULTIMO INFORME.

        # NOTIFICAR AL USUARIO QUE ESTA CREADO UN NUEVO FORMULARIO Y PARA SU COMODIDAD FUERON INICIALIZADOS CON LOS DEL ULTIMO REPORTE.
        for codigo, dimensionDefinicion in dimensiones:
            form_indicadores += '<h3>' + dimensionDefinicion + '</h3>'
            for indicador in lista_indicadores:
                for id_indicador, dimensionIndicador, nombre, tipo in indicador:
                    if codigo == dimensionIndicador:
                        if tipo == 'booleano':
                            form_indicadores += inicializa_booleano_form(nombre, id_indicador, fecha_inicio_previo, fecha_fin_previo)
                        elif tipo == 'choice':
                            form_indicadores += inicializa_choices_form(nombre, id_indicador, fecha_inicio_previo, fecha_fin_previo)
                        elif tipo == 'entero':
                            form_indicadores += inicializa_entero_form(nombre, id_indicador, fecha_inicio_previo, fecha_fin_previo)
                        elif tipo == 'porcentaje':
                            form_indicadores += inicializa_porcentaje_form(nombre, id_indicador, fecha_inicio_previo, fecha_fin_previo)


        if formulario_nuevo == '1':
            formulario_nro = 0

        form_indicadores += '<input type="hidden" value="' + unicode(formulario_nro) + '" name="id_formulario"  id="id_formulario"/><br/><br/><button type="button" id="id_guardar_formulario" class="btn btn-primary">Guardar formulario</button></form>'

        return locals()
    else:
        return 0


def obtener_lista_indicadores():

    # DEFINIMOS LAS DIMENSIONES DE VINCULA ENTORNO
    dimensiones = [(1, u'Formación Continua'), (2, u'Transferencia del conocimiento e innovación'), (3, u'Compromiso social')]
    # OBTENER TODOS LOS INDICADORES.
    booleanos = IndicadoresBooleanos.objects.all()
    choices = IndicadoresChoices.objects.all()
    enteros = IndicadoresEnteros.objects.all()
    porcentajes = IndicadoresPorcentaje.objects.all()
    lista_indicadores = []

    # ORDENAR POR DIMENSION.
    for codigo, dimension in dimensiones:
        lista_auxiliar = []
        for indicador in booleanos:
            if indicador.dimension == codigo:
                lista_auxiliar.append([indicador.id, indicador.dimension, indicador.nombre, 'booleano'])
        for indicador in choices:
            if indicador.dimension == codigo:
                lista_auxiliar.append([indicador.id, indicador.dimension, indicador.nombre, 'choice'])
        for indicador in enteros:
            if indicador.dimension == codigo:
                lista_auxiliar.append([indicador.id, indicador.dimension, indicador.nombre, 'entero'])
        for indicador in porcentajes:
            if indicador.dimension == codigo:
                lista_auxiliar.append([indicador.id, indicador.dimension, indicador.nombre, 'porcentaje'])

        # ORDENAR POR ORDEN ALFABETICO.
        lista_auxiliar.sort(key=lambda x: x[2])

        # CONCATENAR A LA LISTA OFICIAL
        lista_indicadores.append(lista_auxiliar)

    return lista_indicadores


def inicializa_periodo_form(fecha_inicio, fecha_fin):
    auxiliar = """
<div class="periodo-informe">
    <p><font color="red">(*)</font> Campos requeridos</p>
    <legend>Periodo del informe:</legend>
    <table cellpadding="10px" cellspacing="3px" width="100%">
    <tbody>
        <tr>
            <th align="center">Fecha inicio<font color="red">(*)</font>:</th>
            <th align="center">Fecha fin<font color="red">(*)</font>:</th>
        </tr>
        <tr>
            <td align="center">
                <div class="input-append">
                    <input class="datePicker" data-date-format="dd/mm/yyyy" id="id_fecha_inicio" name="fecha_inicio" placeholder='""" + u'DIA/MES/AÑO' + """' value='""" + fecha_inicio + """' type="text">
                    <label for="id_fecha_inicio" class="add-on"><i class="icon-calendar"></i></label>
                </div>
            </td>
            <td align="center">
                <div class="input-append">
                    <input class="datePicker" data-date-format="dd/mm/yyyy" id="id_fecha_fin" name="fecha_fin" placeholder='""" + u'DIA/MES/AÑO' + """' value='""" + fecha_fin + """' type="text">
                    <label for="id_fecha_fin" class="add-on"><i class="icon-calendar"></i></label></div>
            </td>
        </tr>
    </tbody>
    </table>
    <div id="periodo_okay" class="alert alert-success" hidden=""></div>
    <div id="error_periodo" class="alert alert-error" hidden=""></div>
</div>
    """
    return auxiliar


def inicializa_resumen_form(resumen):
    auxiliar = """
            <div class="resumen-informe">
                <legend>
                        Breve resumen del informe<font color="red">(*)</font>:
                </legend>
                <textarea class="textarea.span5" cols="200" id="id_resumen" name="resumen" placeholder="Redacte un breve resumen del informe. Se requiere 30 caracteres como minimo" rows="10">""" + unicode(resumen) + """</textarea>
                <div id="error_resumen" class="alert alert-error"></div>
            </div><br>
    """
    return auxiliar


def inicializa_archivo_form(archivo):
    auxiliar = """
<div class="archivo-informe">
    <legend>
        Archivo/Documento del informe<font color="red">(*)</font>:
    </legend>
    <label>Formatos permitidos: pdf, doc y docx</label>
    """
    if not archivo == '':
        nombre_archivo = unicode(archivo).split('/', 1)
        auxiliar += 'Anterior: <a target=_blank href="/plataforma/plataforma/media/' + unicode(archivo) + '">' + nombre_archivo[-1] + '</a><br>'


    auxiliar += """
    <input id="id_archivo" name="archivo" type="file">
    <div id="archivo_okay" class="alert alert-success" hidden=""></div>
    <div id="error_archivo" class="alert alert-error" hidden=""></div>
</div><br>
    """
    return auxiliar


def inicializa_booleano_form(nombre, identificador, fecha_inicio_previo, fecha_fin_previo):
    respuestas_posibles = [['Si', 1], ['No', 0], ['No aplica', 2]]

    if not fecha_inicio_previo == '' and not fecha_fin_previo == '':
        respuesta_previa = RespuestaBooleanos.objects.filter(indicador=IndicadoresBooleanos.objects.get(id=identificador), fecha_inicio=fecha_inicio_previo , fecha_fin=fecha_fin_previo)

        if respuesta_previa.count() > 0:
            respuesta_valor = respuesta_previa[0].respuesta
        else:
            respuesta_valor = -10
    else:
        respuesta_valor = -10

    auxiliar = '<div class="indicador"> <p><b>' + nombre + '</b></p>'
    for respuesta, valor in respuestas_posibles:
        if valor == respuesta_valor:
            auxiliar += '<label class="radio">' + respuesta + '<input type="radio" id="booleano_' + unicode(identificador) + '" name="booleano_' + unicode(identificador) + '" value="' + unicode(valor) + '" checked="checked"/></label>'
        else:
            auxiliar += '<label class="radio">' + respuesta + '<input type="radio" id="booleano_' + unicode(identificador) + '" name="booleano_' + unicode(identificador) + '" value="' + unicode(valor) + '" /></label>'

    id_elemento = 'booleano' + unicode(identificador)
    auxiliar += imprimir_area_notificaciones(id_elemento) + '</div>'
    return auxiliar


def inicializa_porcentaje_form(nombre, identificador, fecha_inicio_previo, fecha_fin_previo):

    if not fecha_inicio_previo == '' and not fecha_fin_previo == '':
        respuesta_previa = RespuestaPorcentaje.objects.filter(indicador=IndicadoresPorcentaje.objects.get(id=identificador), fecha_inicio=fecha_inicio_previo , fecha_fin=fecha_fin_previo)
        if respuesta_previa.count() > 0:
            valor = respuesta_previa[0].respuesta
        else:
            valor = -10
    else:
        valor = -10


    auxiliar = '<div class="indicador"><p><b>' + nombre + '</b></p>'
    if valor >= 0.0:
        auxiliar += '<p><input type="radio" id="porcentaje_' + unicode(identificador) + '" name="porcentaje_' + unicode(identificador) + '"  value="' + unicode(valor) + '" checked />&nbsp &nbsp'
        auxiliar += '<input type="text" placeholder="Valor entre 0 y 100." class="porcentaje' + unicode(identificador) + '"  value = "' + unicode(valor) + '"/></input></p>'
        auxiliar += '<p><input type="radio" name="porcentaje_' + unicode(identificador) + '" value="" /> &nbsp &nbsp No aplica</p>'
    else:
        if valor == -1:
            auxiliar += '<p><input type="radio" id="porcentaje_' + unicode(identificador) + '" name="porcentaje_' + unicode(identificador) + '"  value="" />&nbsp &nbsp'
            auxiliar += '<input type="text" placeholder="Valor entre 0 y 100." class="porcentaje' + unicode(identificador) + '" value = ""/></input></p> '
            auxiliar += '<p><input type="radio" name="porcentaje_' + unicode(identificador) + '" value="-1" checked/> &nbsp &nbsp No aplica</p>'
        else:
            auxiliar += '<p><input type="radio" id="porcentaje_' + unicode(identificador) + '" name="porcentaje_' + unicode(identificador) + '"  value="" />&nbsp &nbsp'
            auxiliar += '<input type="text" placeholder="Valor entre 0 y 100." class="porcentaje' + unicode(identificador) + '" value = ""/></input></p> '
            auxiliar += '<p><input type="radio" name="porcentaje_' + unicode(identificador) + '" value="-1" /> &nbsp &nbsp No aplica</p>'

    id_elemento = 'porcentaje' + unicode(identificador)
    auxiliar += imprimir_area_notificaciones(id_elemento) + '</div>'

    return auxiliar


def inicializa_entero_form(nombre, identificador, fecha_inicio_previo, fecha_fin_previo):

    if not fecha_inicio_previo == '' and not fecha_fin_previo == '':
        respuesta_previa = RespuestaEnteros.objects.filter(indicador=IndicadoresEnteros.objects.get(id=identificador), fecha_inicio=fecha_inicio_previo , fecha_fin=fecha_fin_previo)

        if respuesta_previa.count() > 0:
            valor = respuesta_previa[0].respuesta
        else:
            valor = -10
    else:
        valor = -10

    valor = int(valor)

    auxiliar = '<div class="indicador"><p><b>' + nombre + '</b></p>'
    if valor >= 0:
        auxiliar += '<p><input type="radio" id="entero_' + unicode(identificador) + '" name="entero_' + unicode(identificador) + '"  value="' + unicode(valor) + '" checked />&nbsp &nbsp'
        auxiliar += '<input type="text" class="entero' + unicode(identificador) + '" value = "' + unicode(valor) + '"/></input></p>'
        auxiliar += '<p><input type="radio" name="entero_' + unicode(identificador) + '" value="" /> &nbsp &nbsp No aplica</p>'
    else:
        if valor == -1:
            auxiliar += '<p><input type="radio" id="entero_' + unicode(identificador) + '" name="entero_' + unicode(identificador) + '"  value="" />&nbsp &nbsp'
            auxiliar += '<input type="text" class="entero' + unicode(identificador) + '"  value = ""/></input></p> '
            auxiliar += '<p><input type="radio" name="entero_' + unicode(identificador) + '" value="-1" checked/> &nbsp &nbsp No aplica</p>'
        else:
            auxiliar += '<p><input type="radio" id="entero_' + unicode(identificador) + '" name="entero_' + unicode(identificador) + '"  value="" />&nbsp &nbsp'
            auxiliar += '<input type="text" class="entero' + unicode(identificador) + '"  value = ""/></input></p> '
            auxiliar += '<p><input type="radio" name="entero_' + unicode(identificador) + '" value="-1" /> &nbsp &nbsp No aplica</p>'
    id_elemento = 'entero' + unicode(identificador)
    auxiliar += imprimir_area_notificaciones(id_elemento) + '</div>'
    return auxiliar


def inicializa_choices_form(nombre, identificador, fecha_inicio_previo, fecha_fin_previo):
    respuestas_posibles = [['Excelente', 4], ['Muy buena', 3], ['Buena', 2], ['Mala', 1], ['No aplica', 5]]

    if not fecha_inicio_previo == '' and not fecha_fin_previo == '':
        respuesta_previa = RespuestaChoices.objects.filter(indicador=IndicadoresChoices.objects.get(id=identificador), fecha_inicio=fecha_inicio_previo , fecha_fin=fecha_fin_previo)

        if respuesta_previa.count() > 0:
            respuesta_valor = respuesta_previa[0].respuesta
        else:
            respuesta_valor = -10
    else:
        respuesta_valor = -10

    auxiliar = '<div class="indicador"><p><b>' + nombre + '</b></p>'
    for respuesta, valor in respuestas_posibles:
        if valor == respuesta_valor:
            auxiliar += '<label class="radio">' + respuesta + '<input type="radio" id="choice_' + unicode(identificador) + '" name="choice_' + unicode(identificador) + '" value="' + unicode(valor) + '" checked="checked" /></label>'
        else:
            auxiliar += '<label class="radio">' + respuesta + '<input type="radio" id="choice_' + unicode(identificador) + '" name="choice_' + unicode(identificador) + '" value="' + unicode(valor) + '" /></label>'

    id_elemento = 'choices' + unicode(identificador)
    auxiliar += imprimir_area_notificaciones(id_elemento) + '</div>'
    return auxiliar


def imprimir_area_notificaciones(id_etiqueta):
    return '<div class="alert alert-warning"></div><div id=' + id_etiqueta + ' class="alert alert-error"></div>'


def definirValor(valor):

    if (valor == 0.0 or valor == 0.00):
        return 0
    if (valor == -1.0 or valor == -1.00):
        return -1
    return valor


def convertir_a_timestamp(fecha):
    return datetime.datetime.strptime(fecha , '%d/%m/%Y').date()


def obtenerFecha(request, pedido):
    if pedido == 'inicio':
        # Devuelve la fecha de inicio del informe
        if request.POST['fecha_inicio'] == '':
            return False, unicode('<li>Verifique fecha de inicio del periodo</li>')
        else:
            return convertir_a_timestamp(request.POST['fecha_inicio']) , ''
    if pedido == 'fin':
        # Devuelve la fecha de fin del informe
        if request.POST['fecha_fin'] == '':
            return False, unicode('<li>Verifique fecha de fin del periodo</li>')
        else:
            return convertir_a_timestamp(request.POST['fecha_fin']) , ''


@csrf_exempt
def ajax_control_periodo(request):
    # Verificar si es una peticion ajax
    if request.is_ajax() and request.method == 'POST':
        bandera, mensaje = validar_periodo(request)
        mensaje = re.sub('<[^<]+?>', '', mensaje)
        respuesta = {'bandera':bandera, "mensaje":mensaje}
        return HttpResponse(simplejson.dumps(respuesta), mimetype='application/json')


@csrf_exempt
def ajax_control_valor(request):
    # Verificar si es una peticion ajax
    if request.is_ajax() and request.method == 'POST':
        bandera, mensaje = verificar_valor(request.POST['valor'] , request.POST['min'] , request.POST['max'])
        mensaje = re.sub('<[^<]+?>', '', mensaje)
        respuesta = {'bandera':bandera, "mensaje":mensaje}
        return HttpResponse(simplejson.dumps(respuesta), mimetype='application/json')




def verificar_valor(valor, minimo, maximo):
    try:
        float(valor)
    except ValueError:
        return False, u'El valor ingresado debe ser numérico. Use puntos y no comas.'

    if maximo == '-1':
        valor = float (valor)
        minimo = float (minimo)
        maximo = float(-1)
    else:
        valor = float(valor)
        minimo = float(minimo)
        maximo = float(maximo)

    if valor >= minimo:
        if not maximo == -1:
            if valor <= maximo:
                return True, "Valor correcto"
            else:
                auxiliar = 'Valor: ' + unicode(valor) + ' incorrecto. Debe encontrarse entre: ' + unicode(minimo) + ' y ' + unicode(maximo)
                return False, auxiliar
        else:
            return True, 'Valor correcto'
    else:
        return False, 'No se permiten valores negativos'



def validar_periodo(request):

    # Obtener informes anteriores.
    universidad_en_cuestion = Universidad.objects.filter(administrador_id=request.user.id)
    informes_anteriores = RespuestaTexto.objects.filter(universidad=universidad_en_cuestion).order_by('-fecha_fin')

    periodo_esta_correcto = True
    mensaje = ''


    # Obtener la fecha de inicio cargada en el formulario
    fecha_inicio_tmp , mensaje_error = obtenerFecha(request, 'inicio')
    if not fecha_inicio_tmp:
        mensaje += mensaje_error


    # 1era Validadcion, si las fechas estan cargadas y tienen el formato correcto
    # Obtener la fecha de fin cargada en el formulario
    fecha_fin_tmp , mensaje_error = obtenerFecha(request, 'fin')
    if not fecha_fin_tmp:
        mensaje += mensaje_error

    # En caso que una de las fechas sean incorrecta, retornar el mensaje para que sea alterada.
    if not fecha_fin_tmp or not fecha_inicio_tmp:
        return False , mensaje



    # 2da validacion, si la fecha de fin es posterior a la fecha de inicio
    if fecha_fin_tmp < fecha_inicio_tmp:
        periodo_esta_correcto = False
        mensaje = '<li>Verifique el periodo, la fecha de inicio es posterior a la fecha de fin</li>'
    else:
        # 3era validacion, Si es la misma fecha de un informe anterior, validarlo.
        nro_formulario = request.POST['id_formulario']
        informe_editado = RespuestaTexto.objects.filter(id=nro_formulario)

        if informe_editado.count() > 0:
            # Si el periodo de un formulario editado es el mismo entonces es valido
            if fecha_fin_tmp.strftime("%d-%m-%Y") == informe_editado[0].fecha_fin.strftime("%d-%m-%Y") and fecha_inicio_tmp.strftime("%d-%m-%Y") == informe_editado[0].fecha_inicio.strftime("%d-%m-%Y"):
                periodo_esta_correcto = True
                mensaje = ''
            else:
                # Caso que el periodo no sea el mismo, verificar solapamiento con otro periodo que no sea el del mismo informe.
                for informe in informes_anteriores:
                    if not unicode(informe.id) == nro_formulario:
                        if fecha_inicio_tmp < informe.fecha_fin and fecha_inicio_tmp > informe.fecha_inicio:
                            periodo_esta_correcto = False
                            break
                        if fecha_fin_tmp > informe.fecha_inicio and fecha_fin_tmp < informe.fecha_fin:
                            periodo_esta_correcto = False
                            break
        else:
            # Caso que el formulario sea nuevo, verificar que no haya solapamiento con otros informes.
            for informe in informes_anteriores:

                # CASO EN QUE ABSORBA TOTALMENTE EL PERIODO DE UN INFORME
                if fecha_inicio_tmp <= informe.fecha_inicio and fecha_fin_tmp >= informe.fecha_fin:
                    periodo_esta_correcto = False
                    break
                # CASO EN QUE EL PERIODO DE INICIO SEA ANTERIOR AL DEL INFORME PERO SU FIN SEA DESPUES PERO ANTES DE LA FECHA DE FIN
                if fecha_inicio_tmp >= informe.fecha_inicio and fecha_inicio_tmp <= informe.fecha_fin:
                    periodo_esta_correcto = False
                    break
                if fecha_fin_tmp >= informe.fecha_inicio and fecha_fin_tmp <= informe.fecha_fin:
                    periodo_esta_correcto = False
                    break


        if periodo_esta_correcto:
            # Periodo correcto, puede validarse
            mensaje = 'Periodo válido'
        else:
            mensaje = unicode('<li>Existe un solapamiento de periodo de informes. El periodo: ' + fecha_inicio_tmp.strftime("%d-%m-%Y") + ' a ' + fecha_fin_tmp.strftime("%d-%m-%Y") + ' se superpone a un informe anterior de: ' + informe.fecha_inicio.strftime("%d-%m-%Y") + ' a ' + informe.fecha_fin.strftime("%d-%m-%Y") + '</li>')

    return periodo_esta_correcto, mensaje


def validar_datos_cargados(request):

    mensaje = 'Favor verfique los siguientes campos:<ul>'

	# verificacion de datos
    bandera_validacion = True

    # Control de fechas.
    bandera_validacion_periodo, mensaje_error = validar_periodo(request)

    if not bandera_validacion_periodo:
        mensaje += 'Favor verifique el periodo.'
        mensaje += '<ul>' + mensaje_error + '</ul>'

        if bandera_validacion:
            bandera_validacion = False

    return bandera_validacion , mensaje


def listar_informes_anteriores(request, universidad_pedida):

    if checkpermiso(request.user, Permisos):
        return HttpResponse(respuestahttp())

    # Revisar si es administrador regional
    is_adm_regional = request.user.groups.filter(name='Adm. Regional').exists()
    is_adm_institucional = request.user.groups.filter(name='Adm. Institucional').exists()

    mensaje = ""
    if "message" in request.GET:
        mensaje = request.GET["message"]

    universidad_en_cuestion = Universidad.objects.get(id=universidad_pedida)
    periodos = RespuestaTexto.objects.filter(universidad=universidad_en_cuestion).order_by('-fecha_fin')

    bandera_control = True
    datos = []

    if periodos.count() > 0:
        bandera_control = True
        for periodo in periodos:
            datos.append((periodo.fecha_inicio.strftime("%d-%m-%Y"), periodo.fecha_fin.strftime("%d-%m-%Y") , periodo.id))
    else:
        bandera_control = False

    menu = sidebar(request)
    return render_to_response('listar_informes_anteriores.html', locals(), context_instance=RequestContext(request))


def ver_informe_viejo(request, codigo_informe):

    datos_indicadores_texto = RespuestaTexto.objects.get(id=codigo_informe)
    datos_indicadores_booleanos = RespuestaBooleanos.objects.filter(fecha_fin=datos_indicadores_texto.fecha_fin)
    datos_indicadores_choices = RespuestaChoices.objects.filter(fecha_fin=datos_indicadores_texto.fecha_fin)
    datos_indicadores_enteros = RespuestaEnteros.objects.filter(fecha_fin=datos_indicadores_texto.fecha_fin)
    datos_indicadores_porcentaje = RespuestaPorcentaje.objects.filter(fecha_fin=datos_indicadores_texto.fecha_fin)

    universidad = Universidad.objects.get(id=datos_indicadores_texto.universidad_id)
    inicio = datos_indicadores_texto.fecha_inicio.strftime("%d-%m-%Y")
    fin = datos_indicadores_texto.fecha_fin.strftime("%d-%m-%Y")

    respuestas_boolean = ('No', 'Si', 'No aplica')
    respuestas_choices = ('Mala', 'Buena', 'Muy Buena', 'Excelente', 'No aplica')
    read_more = ""

    for i in range(1, 4):
        if i == 1:
            read_more += u"<h3>Formación Continua </h3><br/>"
        elif i == 2:
            read_more += u"<h3>Tranferencia del conocimiento e innovación </h3><br/>"
        elif i == 3:
            read_more += u"<h3>Compromiso social  </h3><br/>"

        for elemento in datos_indicadores_booleanos:
            etiqueta_indicador = IndicadoresBooleanos.objects.get(id=elemento.indicador_id)
            if etiqueta_indicador.dimension == i:
                read_more += "<p>" + etiqueta_indicador.nombre + ": <b>" + respuestas_boolean[int(elemento.respuesta)] + "</b></p>"
        for elemento in datos_indicadores_choices:
            etiqueta_indicador = IndicadoresChoices.objects.get(id=elemento.indicador_id)
            if etiqueta_indicador.dimension == i:
                read_more += "<p>" + etiqueta_indicador.nombre + ": <b>" + respuestas_choices[int(elemento.respuesta) - 1] + "</b></p>"
        for elemento in datos_indicadores_enteros:
            etiqueta_indicador = IndicadoresEnteros.objects.get(id=elemento.indicador_id)
            if etiqueta_indicador.dimension == i:
                if elemento.respuesta < 0:
                    read_more += "<p>" + etiqueta_indicador.nombre + ": <b>" + 'No aplica' + "</b></p>"
                else:
                    read_more += "<p>" + etiqueta_indicador.nombre + ": <b>" + unicode(elemento.respuesta) + "</b></p>"
        for elemento in datos_indicadores_porcentaje:
            etiqueta_indicador = IndicadoresPorcentaje.objects.get(id=elemento.indicador_id)
            if etiqueta_indicador.dimension == i:
                if elemento.respuesta < 0:
                    read_more += "<p>" + etiqueta_indicador.nombre + ": <b>" + 'No aplica' + "</b></p>"
                else:
                    read_more += "<p>" + etiqueta_indicador.nombre + ": <b>" + unicode(elemento.respuesta) + "</b></p>"

    menu = sidebar(request)

    context_instance = RequestContext(request)
    return render_to_response('ver_informe_viejo.html', locals(), context_instance=context_instance)

